home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #9 / Amiga Plus CD - 2004 - No. 09.iso / amigaplus / tools / amigaos4_only / mpega_libmad / support.c < prev    next >
C/C++ Source or Header  |  2004-08-03  |  5KB  |  296 lines
  1. #include <exec/memory.h>
  2. #include <exec/semaphores.h>
  3. #include <proto/exec.h>
  4. #include <proto/dos.h>
  5.  
  6. #ifdef BUILD_POWERUP
  7. #include <powerup/gcclib/powerup_protos.h>
  8.  
  9. struct ExecBase *SysBase = NULL;
  10. struct DosLibrary *DOSBase = NULL;
  11. #endif
  12.  
  13. #ifdef BUILD_WARPUP
  14. #include <powerpc/powerpc.h>
  15. #include <proto/powerpc.h>
  16. #endif
  17.  
  18. #include "compiler.h"
  19.  
  20. #define PoolSize 131072
  21. static void *MemPool = NULL;
  22. #ifdef BUILD_POWERUP
  23. static void *PoolSem = NULL;
  24. #elif defined(BUILD_WARPUP)
  25. static struct SignalSemaphorePPC PoolSem;
  26. #else
  27. static struct SignalSemaphore PoolSem;
  28. #endif
  29.  
  30. ULONG LIBPPC InitSupport(void)
  31. {
  32. #ifdef BUILD_POWERUP
  33.     SysBase = *((struct ExecBase **)4L);
  34.  
  35.     if ((DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 36)))
  36.     {
  37.         if ((MemPool = PPCCreatePool(MEMF_PUBLIC, PoolSize, PoolSize)))
  38.         {
  39.             if ((PoolSem = PPCCreateSemaphore(NULL))) return 1;
  40.         }
  41.     }
  42. #elif defined(BUILD_WARPUP)
  43.     if ((MemPool = CreatePoolPPC(MEMF_PUBLIC, PoolSize, PoolSize)))
  44.     {
  45.         InitSemaphorePPC(&PoolSem);
  46.         return 1;
  47.     }
  48. #else
  49. #ifdef BUILD_OS4
  50.     if ((MemPool = CreatePool(MEMF_SHARED, PoolSize, PoolSize)))
  51. #else
  52.     if ((MemPool = CreatePool(MEMF_PUBLIC, PoolSize, PoolSize)))
  53. #endif
  54.     {
  55.         InitSemaphore(&PoolSem);
  56.         return 1;
  57.     }
  58. #endif
  59.  
  60.     return 0;
  61. }
  62.  
  63. void LIBPPC RemoveSupport(void)
  64. {
  65. #ifdef BUILD_POWERUP
  66.     if (DOSBase)
  67.         CloseLibrary((struct Library *)DOSBase);
  68.  
  69.     if (PoolSem)
  70.         PPCDeleteSemaphore(PoolSem);
  71. #endif
  72.  
  73. #ifdef BUILD_WARPUP
  74.     FreeSemaphorePPC(&PoolSem);
  75. #endif
  76.  
  77.     if (MemPool)
  78.     {
  79. #ifdef BUILD_POWERUP
  80.         PPCDeletePool(MemPool);
  81. #elif defined(BUILD_WARPUP)
  82.         DeletePoolPPC(MemPool);
  83. #else
  84.         DeletePool(MemPool);
  85. #endif
  86.         MemPool = NULL;
  87.     }
  88. }
  89.  
  90. #ifdef __PPC__
  91. #include <string.h>
  92. #else
  93. void bcopy(const void *s1, void *s2, unsigned long n)
  94. {
  95.     unsigned long m;
  96.  
  97.     if (!n) return;
  98.  
  99.     if (s2 < s1)
  100.     {
  101.         if ((long)s1 & 1)
  102.         {
  103.             *((char *)s2)++ = *((char *)s1)++;
  104.             n--;
  105.         }
  106.  
  107.         if (!((long)s2 & 1))
  108.         {
  109.             m = n / sizeof(long);
  110.             n &= sizeof(long) - 1;
  111.  
  112.             for (; m; m--)
  113.             {
  114.                 *((long *)s2)++ = *((long *)s1)++;
  115.             }
  116.         }
  117.  
  118.         for (; n; n--)
  119.         {
  120.             *((char *)s2)++=*((char *)s1)++;
  121.         }
  122.     } else {
  123.         (char *)s1 += n;
  124.         (char *)s2 += n;
  125.  
  126.         if ((long)s1 & 1)
  127.         {
  128.             *--((char *)s2) = *--((char *)s1);
  129.             n--;
  130.         }
  131.  
  132.         if (!((long)s2 & 1))
  133.         {
  134.             m = n / sizeof(long);
  135.             n &= sizeof(long) - 1;
  136.  
  137.             for (; m; m--)
  138.             {
  139.                 *--((long *)s2) = *--((long *)s1);
  140.             }
  141.         }
  142.  
  143.         for (; n; n--)
  144.         {
  145.             *--((char *)s2) = *--((char *)s1);
  146.         }
  147.     }
  148. }
  149.  
  150. void bzero(void *ptr, unsigned long siz)
  151. {
  152.     long lsize, bsize;
  153.     unsigned long *l;
  154.     unsigned char *b;
  155.  
  156.     lsize = siz >> 5;
  157.     bsize = siz & 3;
  158.     siz = (siz & 31) >> 2;
  159.  
  160.     l = ptr;
  161.     l--;
  162.  
  163.     while (lsize > 0)
  164.     {
  165.         *++l = 0;
  166.         *++l = 0;
  167.         *++l = 0;
  168.         *++l = 0;
  169.         *++l = 0;
  170.         *++l = 0;
  171.         *++l = 0;
  172.         *++l = 0;
  173.         lsize--;
  174.     }
  175.  
  176.     while (siz > 0)
  177.     {
  178.         *++l = 0;
  179.         siz--;
  180.     }
  181.  
  182.     b = (unsigned char *)l;
  183.     b += 3;
  184.  
  185.     while (bsize > 0)
  186.     {
  187.         *++b = 0;
  188.         bsize--;
  189.     }
  190. }
  191.  
  192. void *memcpy(void *s1, const void *s2, unsigned long n)
  193. {
  194.     bcopy(s2,s1,n);
  195.  
  196.     return s1;
  197. }
  198.  
  199. void *memmove(void *s1, const void *s2, unsigned long n)
  200. {
  201.     bcopy(s2,s1,n);
  202.  
  203.     return s1;
  204. }
  205.  
  206. void *memset(void *s, int c, unsigned long n)
  207. {
  208.     if (n != 0)
  209.     {
  210.         unsigned char *p = s;
  211.  
  212.         do {
  213.             *p++ = c;
  214.         } while (--n != 0);
  215.     }
  216.  
  217.     return s;
  218. }
  219. #endif
  220.  
  221. void *malloc(unsigned long size)
  222. {
  223.     ULONG *MyMemory;
  224.  
  225.     if (size == 0) return NULL;
  226.     size += 8;
  227.  
  228. #ifdef BUILD_POWERUP
  229.     PPCObtainSemaphore(PoolSem);
  230.     MyMemory = (ULONG *)PPCAllocPooled(MemPool, size);
  231.     PPCReleaseSemaphore(PoolSem);
  232. #elif defined(BUILD_WARPUP)
  233.     ObtainSemaphorePPC(&PoolSem);
  234.     MyMemory = (ULONG *)AllocPooledPPC(MemPool, size);
  235.     ReleaseSemaphorePPC(&PoolSem);
  236. #else
  237.     ObtainSemaphore(&PoolSem);
  238.     MyMemory = (ULONG *)AllocPooled(MemPool, size);
  239.     ReleaseSemaphore(&PoolSem);
  240. #endif
  241.  
  242.     if (MyMemory)
  243.     {
  244.         *MyMemory++ = size;
  245.  
  246.         if ((ULONG)MyMemory & 7)
  247.         {
  248.             *MyMemory++ = 0;
  249.         }
  250.     }
  251.  
  252.     return((void *)MyMemory);
  253. }
  254.  
  255. void *calloc(unsigned long nobj, unsigned long size)
  256. {
  257.     unsigned long siz = size * nobj;
  258.     void *ptr;
  259.  
  260.     if ((ptr = malloc(siz)))
  261.         bzero(ptr, siz);
  262.  
  263.     return ptr;
  264. }
  265.  
  266. void free(void *ptr)
  267. {
  268.     ULONG *MemPtr;
  269.     ULONG Size;
  270.  
  271.     if (ptr == NULL) return;
  272.  
  273.     MemPtr = ptr;
  274.     Size = *--MemPtr;
  275.  
  276.     if (Size == 0)
  277.     {
  278.         Size = *--MemPtr;
  279.     }
  280.  
  281. #ifdef BUILD_POWERUP
  282.     PPCObtainSemaphore(PoolSem);
  283.     PPCFreePooled(MemPool, MemPtr, Size);
  284.     PPCReleaseSemaphore(PoolSem);
  285. #elif defined(BUILD_WARPUP)
  286.     ObtainSemaphorePPC(&PoolSem);
  287.     FreePooledPPC(MemPool, MemPtr, Size);
  288.     ReleaseSemaphorePPC(&PoolSem);
  289. #else
  290.     ObtainSemaphore(&PoolSem);
  291.     FreePooled(MemPool, MemPtr, Size);
  292.     ReleaseSemaphore(&PoolSem);
  293. #endif
  294. }
  295.  
  296.